Pythons ast-modul: Avmystifisering av manipulering av abstrakte syntakstrær

Pythons ast-modul gir en kraftig måte å samhandle med det abstrakte syntakstreet (AST) til Python-kode. Et AST er en tre-representasjon av den syntaktiske strukturen til kildekoden, noe som gjør det mulig å programmatisk analysere, modifisere og til og med generere Python-kode. Dette åpner døren for ulike anvendelser, inkludert kodeanalyseverktøy, automatisert refaktorering, statisk analyse og til og med tilpassede språkutvidelser. Denne artikkelen vil guide deg gjennom det grunnleggende i ast-modulen, med praktiske eksempler og innsikt i dens kapabiliteter.

Hva er et abstrakt syntakstre (AST)?

Før vi dykker ned i ast-modulen, la oss forstå hva et abstrakt syntakstre er. Når en Python-tolk kjører koden din, er det første steget å parse koden til et AST. Denne trestrukturen representerer kodens syntaktiske elementer, som funksjoner, klasser, løkker, uttrykk og operatorer, sammen med deres relasjoner. AST-et forkaster irrelevante detaljer som mellomrom og kommentarer, og fokuserer på den essensielle strukturelle informasjonen. Ved å representere kode på denne måten blir det mulig for programmer å analysere og manipulere selve koden, noe som er ekstremt nyttig i mange situasjoner.

Kom i gang med ast-modulen

ast-modulen er en del av Pythons standardbibliotek, så du trenger ikke å installere noen ekstra pakker. Bare importer den for å begynne å bruke den:

            import ast
            

              
                Copy
              
            
          

Kjernefunksjonen i ast-modulen er ast.parse(), som tar en streng med Python-kode som input og returnerer et AST-objekt.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast_tree)
            

              
                Copy
              
            
          

Dette vil gi en utskrift som ligner på: <_ast.Module object at 0x...>. Selv om denne utskriften ikke er spesielt informativ, indikerer den at koden ble vellykket parset til et AST. ast_tree-objektet inneholder nå hele strukturen til den parsede koden.

Utforske AST-et

For å forstå strukturen til AST-et, kan vi bruke ast.dump()-funksjonen. Denne funksjonen traverserer treet rekursivt og skriver ut en detaljert representasjon av hver node.

            code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)
print(ast.dump(ast_tree, indent=4))
            

              
                Copy
              
            
          

Utskriften vil være:

            Module(
    body=[
        FunctionDef(
            name='add',
            args=arguments(
                posonlyargs=[],
                args=[
                    arg(arg='x', annotation=None, type_comment=None),
                    arg(arg='y', annotation=None, type_comment=None)
                ],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                Return(
                    value=BinOp(
                        left=Name(id='x', ctx=Load()),
                        op=Add(),
                        right=Name(id='y', ctx=Load())
                    )
                )
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    type_ignores=[]
)
            

              
                Copy
              
            
          

Denne utskriften viser den hierarkiske strukturen til koden. La oss bryte den ned:

• Module: Rotnoden som representerer hele modulen.
• body: En liste over setninger i modulen.
• FunctionDef: Representerer en funksjonsdefinisjon. Dens attributter inkluderer:
• name: Navnet på funksjonen ('add').
• args: Argumentene til funksjonen.
• arguments: Inneholder informasjon om funksjonens argumenter.
• arg: Representerer et enkelt argument (f.eks. 'x', 'y').
• body: Kroppen til funksjonen (en liste over setninger).
• Return: Representerer en return-setning.
• value: Verdien som returneres.
• BinOp: Representerer en binær operasjon (f.eks. x + y).
• left: Den venstre operanden (f.eks. 'x').
• op: Operatoren (f.eks. 'Add').
• right: Den høyre operanden (f.eks. 'y').

Traversering av AST-et

ast-modulen tilbyr ast.NodeVisitor-klassen for å traversere AST-et. Ved å subklasse ast.NodeVisitor og overstyre metodene dens, kan du behandle spesifikke nodetyper etter hvert som de blir møtt under traverseringen. Dette er nyttig for å analysere kodestruktur, identifisere spesifikke mønstre eller hente ut informasjon.

            import ast

class FunctionNameExtractor(ast.NodeVisitor):
    def __init__(self):
        self.function_names = []

    def visit_FunctionDef(self, node):
        self.function_names.append(node.name)

code = """
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y
"""

ast_tree = ast.parse(code)

extractor = FunctionNameExtractor()
extractor.visit(ast_tree)

print(extractor.function_names)  # Utskrift: ['add', 'subtract']
            

              
                Copy
              
            
          

I dette eksempelet arver FunctionNameExtractor fra ast.NodeVisitor og overstyrer visit_FunctionDef-metoden. Denne metoden kalles for hver funksjonsdefinisjonsnode i AST-et. Metoden legger til funksjonsnavnet i listen function_names. visit()-metoden starter traverseringen av AST-et.

Eksempel: Finne alle variabeltildelinger

            import ast

class VariableAssignmentFinder(ast.NodeVisitor):
    def __init__(self):
        self.assignments = []

    def visit_Assign(self, node):
        for target in node.targets:
            if isinstance(target, ast.Name):
                self.assignments.append(target.id)

code = """
x = 10
y = x + 5
message = "hello"
"""

ast_tree = ast.parse(code)

finder = VariableAssignmentFinder()
finder.visit(ast_tree)

print(finder.assignments)  # Utskrift: ['x', 'y', 'message']
            

              
                Copy
              
            
          

Dette eksempelet finner alle variabeltildelinger i koden. visit_Assign-metoden kalles for hver tildelingssetning. Den itererer gjennom målene for tildelingen, og hvis et mål er et enkelt navn (ast.Name), legger den til navnet i assignments-listen.

Modifisering av AST-et

ast-modulen lar deg også modifisere AST-et. Du kan endre eksisterende noder, legge til nye noder, eller fjerne noder helt. For å modifisere AST-et bruker du ast.NodeTransformer-klassen. I likhet med ast.NodeVisitor, subklasser du ast.NodeTransformer og overstyrer metodene dens for å modifisere spesifikke nodetyper. Den viktigste forskjellen er at metodene i ast.NodeTransformer skal returnere den modifiserte noden (eller en ny node for å erstatte den). Hvis en metode returnerer None, fjernes noden fra AST-et.

Etter å ha modifisert AST-et, må du kompilere det tilbake til kjørbar Python-kode ved hjelp av compile()-funksjonen.

            import ast

class AddOneTransformer(ast.NodeTransformer):
    def visit_Num(self, node):
        return ast.Num(n=node.n + 1)

code = """
x = 10
y = 20
"""

ast_tree = ast.parse(code)

transformer = AddOneTransformer()
new_ast_tree = transformer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Kjør den modifiserte koden
exec(new_code)

print(x)  # Utskrift: 11
print(y)  # Utskrift: 21
            

              
                Copy
              
            
          

I dette eksempelet arver AddOneTransformer fra ast.NodeTransformer og overstyrer visit_Num-metoden. Denne metoden kalles for hver numerisk literal-node (ast.Num). Metoden oppretter en ny ast.Num-node med verdien økt med 1. visit()-metoden returnerer det modifiserte AST-et.

compile()-funksjonen tar det modifiserte AST-et, et filnavn (<string> i dette tilfellet, som indikerer at koden kommer fra en streng), og en kjøringsmodus ('exec' for å kjøre en kodeblokk). Den returnerer et kodeobjekt som kan kjøres ved hjelp av exec()-funksjonen.

Eksempel: Erstatte et variabelnavn

            import ast

class VariableNameReplacer(ast.NodeTransformer):
    def __init__(self, old_name, new_name):
        self.old_name = old_name
        self.new_name = new_name

    def visit_Name(self, node):
        if node.id == self.old_name:
            return ast.Name(id=self.new_name, ctx=node.ctx)
        return node

code = """
def multiply_by_two(number):
    return number * 2

result = multiply_by_two(5)
print(result)
"""

ast_tree = ast.parse(code)

replacer = VariableNameReplacer('number', 'num')
new_ast_tree = replacer.visit(ast_tree)

new_code = compile(new_ast_tree, '', 'exec')

# Kjør den modifiserte koden
exec(new_code)

            

              
                Copy
              
            
          

Dette eksempelet erstatter alle forekomster av variabelnavnet 'number' med 'num'. VariableNameReplacer tar det gamle og nye navnet som argumenter. visit_Name-metoden kalles for hver navnenode. Hvis nodens identifikator samsvarer med det gamle navnet, oppretter den en ny ast.Name-node med det nye navnet og samme kontekst (node.ctx). Konteksten indikerer hvordan navnet blir brukt (f.eks. lasting, lagring).

Generere kode fra et AST

Selv om compile() lar deg kjøre kode fra et AST, gir det ikke en måte å få koden som en streng. For å generere Python-kode fra et AST, kan du bruke astunparse-biblioteket. Dette biblioteket er ikke en del av standardbiblioteket, så du må installere det først:

            pip install astunparse
            

              
                Copy
              
            
          

Deretter kan du bruke astunparse.unparse()-funksjonen til å generere kode fra et AST.

            import ast
import astunparse

code = """
def add(x, y):
    return x + y
"""

ast_tree = ast.parse(code)

generated_code = astunparse.unparse(ast_tree)

print(generated_code)
            

              
                Copy
              
            
          

Utskriften vil være:

            def add(x, y):
    return (x + y)

            

              
                Copy
              
            
          

Merk: Parentesene rundt (x + y) er lagt til av astunparse for å sikre korrekt operatorprioritet. Disse parentesene er kanskje ikke strengt nødvendige, men de garanterer at koden er korrekt.

Eksempel: Generere en enkel klasse

            import ast
import astunparse

class_name = 'MyClass'
method_name = 'my_method'

# Opprett klassedefinisjonsnoden
class_def = ast.ClassDef(
    name=class_name,
    bases=[],
    keywords=[],
    body=[
        ast.FunctionDef(
            name=method_name,
            args=ast.arguments(
                posonlyargs=[],
                args=[],
                kwonlyargs=[],
                kw_defaults=[],
                defaults=[]
            ),
            body=[
                ast.Pass()
            ],
            decorator_list=[],
            returns=None,
            type_comment=None
        )
    ],
    decorator_list=[]
)

# Opprett modulnoden som inneholder klassedefinisjonen
module = ast.Module(body=[class_def], type_ignores=[])

# Generer koden
code = astunparse.unparse(module)

print(code)
            

              
                Copy
              
            
          

Dette eksempelet genererer følgende Python-kode:

            class MyClass:

    def my_method():
        pass

            

              
                Copy
              
            
          

Dette demonstrerer hvordan man bygger et AST fra bunnen av og deretter genererer kode fra det. Denne tilnærmingen er kraftig for kodegenereringsverktøy og metaprogrammering.

Praktiske anvendelser av ast-modulen

ast-modulen har mange praktiske anvendelser, inkludert:

• Kodeanalyse: Analysere kode for stilbrudd, sikkerhetssårbarheter eller ytelsesflaskehalser. For eksempel kan du skrive et verktøy for å håndheve kodestandarder i et stort prosjekt.
• Automatisert refaktorering: Automatisere oppgaver som å endre navn på variabler, trekke ut metoder, eller konvertere kode til å bruke nyere språkfunksjoner. Verktøy som `rope` utnytter AST-er for kraftige refaktoreringsmuligheter.
• Statisk analyse: Identifisere potensielle feil eller bugs i kode uten å faktisk kjøre den. Verktøy som `pylint` og `flake8` bruker AST-analyse for å oppdage problemer.
• Kodegenerering: Generere kode automatisk basert på maler eller spesifikasjoner. Dette er nyttig for å lage repetitiv kode eller generere kode for forskjellige plattformer.
• Språkutvidelser: Lage tilpassede språkutvidelser eller domenespesifikke språk (DSL-er) ved å transformere Python-kode til forskjellige representasjoner.
• Sikkerhetsrevisjon: Analysere kode for potensielt skadelige konstruksjoner eller sårbarheter. Dette kan brukes til å identifisere usikre kodingspraksiser.

Eksempel: Håndheve kodestil

La oss si at du vil håndheve at alle funksjonsnavn i prosjektet ditt følger snake_case-konvensjonen (f.eks. my_function i stedet for myFunction). Du kan bruke ast-modulen for å se etter brudd.

            import ast
import re

class SnakeCaseChecker(ast.NodeVisitor):
    def __init__(self):
        self.errors = []

    def visit_FunctionDef(self, node):
        if not re.match(r'^[a-z]+(_[a-z]+)*$', node.name):
            self.errors.append(f"Funksjonsnavnet '{node.name}' følger ikke snake_case-konvensjonen")

    def check_code(self, code):
        ast_tree = ast.parse(code)
        self.visit(ast_tree)
        return self.errors

# Eksempel på bruk
code = """
def myFunction(x):
    return x * 2

def calculate_area(width, height):
    return width * height
"""

checker = SnakeCaseChecker()
errors = checker.check_code(code)

if errors:
    for error in errors:
        print(error)
else:
    print("Ingen stilbrudd funnet")
            

              
                Copy
              
            
          

Denne koden definerer en SnakeCaseChecker-klasse som arver fra ast.NodeVisitor. visit_FunctionDef-metoden sjekker om funksjonsnavnet samsvarer med det regulære uttrykket for snake_case. Hvis ikke, legger den til en feilmelding i errors-listen. check_code-metoden parser koden, traverserer AST-et og returnerer listen over feil.

Beste praksis når du jobber med ast-modulen

• Forstå AST-strukturen: Før du prøver å manipulere AST-et, ta deg tid til å forstå strukturen ved hjelp av ast.dump(). Dette vil hjelpe deg med å identifisere nodene du trenger å jobbe med.
• Bruk ast.NodeVisitor og ast.NodeTransformer: Disse klassene gir en praktisk måte å traversere og modifisere AST-et på uten å måtte navigere treet manuelt.
• Test grundig: Når du modifiserer AST-et, test koden din grundig for å sikre at endringene er korrekte og ikke introduserer noen feil.
• Vurder astunparse for kodegenerering: Mens compile() er nyttig for å kjøre modifisert kode, gir astunparse en måte å generere lesbar Python-kode fra et AST.
• Bruk typehint: Typehint kan forbedre lesbarheten og vedlikeholdbarheten av koden din betydelig, spesielt når du jobber med komplekse AST-strukturer.
• Dokumenter koden din: Når du lager tilpassede AST-visitors eller -transformers, dokumenter koden din tydelig for å forklare formålet med hver metode og endringene den gjør i AST-et.

Utfordringer og hensyn

• Kompleksitet: Å jobbe med AST-er kan være komplekst, spesielt for større kodebaser. Å forstå de forskjellige nodetypene og deres relasjoner kan være utfordrende.
• Vedlikehold: AST-strukturer kan endre seg mellom Python-versjoner. Sørg for å teste koden din med forskjellige Python-versjoner for å sikre kompatibilitet.
• Ytelse: Traversering og modifisering av store AST-er kan være tregt. Vurder å optimalisere koden din for å forbedre ytelsen. Caching av ofte brukte noder eller bruk av mer effektive algoritmer kan hjelpe.
• Feilhåndtering: Håndter feil på en elegant måte når du parser eller manipulerer AST-et. Gi informative feilmeldinger til brukeren.
• Sikkerhet: Vær forsiktig når du kjører kode generert fra et AST, spesielt hvis AST-et er basert på brukerinput. Saniter input for å forhindre kodeinjeksjonsangrep.

Konklusjon

Pythons ast-modul gir en kraftig og fleksibel måte å samhandle med det abstrakte syntakstreet til Python-kode. Ved å forstå AST-strukturen og bruke klassene ast.NodeVisitor og ast.NodeTransformer, kan du analysere, modifisere og generere Python-kode programmatisk. Dette åpner døren for et bredt spekter av applikasjoner, fra kodeanalyseverktøy til automatisert refaktorering og til og med tilpassede språkutvidelser. Selv om det kan være komplekst å jobbe med AST-er, er fordelene med å kunne manipulere kode programmatisk betydelige. Omfavn kraften i ast-modulen for å låse opp nye muligheter i dine Python-prosjekter.